ProfessionalWiki / Bootstrap

  * Bootstrap tooltip.js v4.6.1 (https://getbootstrap.com/)

  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)

  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)

  */

(function (global, factory) {

  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery'), require('popper.js'), require('./util.js')) :

  typeof define === 'function' && define.amd ? define(['jquery', 'popper.js', './util'], factory) :

  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Tooltip = factory(global.jQuery, global.Popper, global.Util));

})(this, (function ($, Popper, Util) { 'use strict';

  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

  var $__default = /*#__PURE__*/_interopDefaultLegacy($);

  var Popper__default = /*#__PURE__*/_interopDefaultLegacy(Popper);

  var Util__default = /*#__PURE__*/_interopDefaultLegacy(Util);

  function _defineProperties(target, props) {

    for (var i = 0; i < props.length; i++) {

      var descriptor = props[i];

      descriptor.enumerable = descriptor.enumerable || false;

      descriptor.configurable = true;

      if ("value" in descriptor) descriptor.writable = true;

      Object.defineProperty(target, descriptor.key, descriptor);

    }

  }

  function _createClass(Constructor, protoProps, staticProps) {

    if (protoProps) _defineProperties(Constructor.prototype, protoProps);

    if (staticProps) _defineProperties(Constructor, staticProps);

    return Constructor;

  }

  function _extends() {

    _extends = Object.assign || function (target) {

      for (var i = 1; i < arguments.length; i++) {

        var source = arguments[i];

        for (var key in source) {

          if (Object.prototype.hasOwnProperty.call(source, key)) {

            target[key] = source[key];

          }

        }

      }

      return target;

    };

    return _extends.apply(this, arguments);

  }

  /**

   * --------------------------------------------------------------------------

   * Bootstrap (v4.6.1): tools/sanitizer.js

   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)

   * --------------------------------------------------------------------------

   */

  var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href'];

  var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;

  var DefaultWhitelist = {

    // Global attributes allowed on any supplied element below.

    '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],

    a: ['target', 'href', 'title', 'rel'],

    area: [],

    b: [],

    br: [],

    col: [],

    code: [],

    div: [],

    em: [],

    hr: [],

    h1: [],

    h2: [],

    h3: [],

    h4: [],

    h5: [],

    h6: [],

    i: [],

    img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],

    li: [],

    ol: [],

    p: [],

    pre: [],

    s: [],

    small: [],

    span: [],

    sub: [],

    sup: [],

    strong: [],

    u: [],

    ul: []

  };

  /**

   * A pattern that recognizes a commonly useful subset of URLs that are safe.

   *

   * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts

   */

  var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i;

  /**

   * A pattern that matches safe data URLs. Only matches image, video and audio types.

   *

   * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts

   */

  var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i;

  function allowedAttribute(attr, allowedAttributeList) {

    var attrName = attr.nodeName.toLowerCase();

    if (allowedAttributeList.indexOf(attrName) !== -1) {

      if (uriAttrs.indexOf(attrName) !== -1) {

        return Boolean(SAFE_URL_PATTERN.test(attr.nodeValue) || DATA_URL_PATTERN.test(attr.nodeValue));

      }

      return true;

    }

    var regExp = allowedAttributeList.filter(function (attrRegex) {

      return attrRegex instanceof RegExp;

    }); // Check if a regular expression validates the attribute.

    for (var i = 0, len = regExp.length; i < len; i++) {

      if (regExp[i].test(attrName)) {

        return true;

      }

    }

    return false;

  }

  function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) {

    if (unsafeHtml.length === 0) {

      return unsafeHtml;

    }

    if (sanitizeFn && typeof sanitizeFn === 'function') {

      return sanitizeFn(unsafeHtml);

    }

    var domParser = new window.DOMParser();

    var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');

    var whitelistKeys = Object.keys(whiteList);

    var elements = [].slice.call(createdDocument.body.querySelectorAll('*'));

    var _loop = function _loop(i, len) {

      var el = elements[i];

      var elName = el.nodeName.toLowerCase();

      if (whitelistKeys.indexOf(el.nodeName.toLowerCase()) === -1) {

        el.parentNode.removeChild(el);

        return "continue";

      }

      var attributeList = [].slice.call(el.attributes); // eslint-disable-next-line unicorn/prefer-spread

      var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []);

      attributeList.forEach(function (attr) {

        if (!allowedAttribute(attr, whitelistedAttributes)) {

          el.removeAttribute(attr.nodeName);

        }

      });

    };

    for (var i = 0, len = elements.length; i < len; i++) {

      var _ret = _loop(i);

      if (_ret === "continue") continue;

    }

    return createdDocument.body.innerHTML;

  }

  /**

   * Constants

   */

  var NAME = 'tooltip';

  var VERSION = '4.6.1';

  var DATA_KEY = 'bs.tooltip';

  var EVENT_KEY = "." + DATA_KEY;

  var JQUERY_NO_CONFLICT = $__default["default"].fn[NAME];

  var CLASS_PREFIX = 'bs-tooltip';

  var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');

  var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn'];

  var CLASS_NAME_FADE = 'fade';

  var CLASS_NAME_SHOW = 'show';

  var HOVER_STATE_SHOW = 'show';

  var HOVER_STATE_OUT = 'out';

  var SELECTOR_TOOLTIP_INNER = '.tooltip-inner';

  var SELECTOR_ARROW = '.arrow';

  var TRIGGER_HOVER = 'hover';

  var TRIGGER_FOCUS = 'focus';

  var TRIGGER_CLICK = 'click';

  var TRIGGER_MANUAL = 'manual';

  var AttachmentMap = {

    AUTO: 'auto',

    TOP: 'top',

    RIGHT: 'right',

    BOTTOM: 'bottom',

    LEFT: 'left'

  };

  var Default = {

    animation: true,

    template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>',

    trigger: 'hover focus',

    title: '',

    delay: 0,

    html: false,

    selector: false,

    placement: 'top',

    offset: 0,

    container: false,

    fallbackPlacement: 'flip',

    boundary: 'scrollParent',

    customClass: '',

    sanitize: true,

    sanitizeFn: null,

    whiteList: DefaultWhitelist,

    popperConfig: null

  };

  var DefaultType = {

    animation: 'boolean',

    template: 'string',

    title: '(string|element|function)',

    trigger: 'string',

    delay: '(number|object)',

    html: 'boolean',

    selector: '(string|boolean)',

    placement: '(string|function)',

    offset: '(number|string|function)',

    container: '(string|element|boolean)',

    fallbackPlacement: '(string|array)',

    boundary: '(string|element)',

    customClass: '(string|function)',

    sanitize: 'boolean',

    sanitizeFn: '(null|function)',

    whiteList: 'object',

    popperConfig: '(null|object)'

  };

  var Event = {

    HIDE: "hide" + EVENT_KEY,

    HIDDEN: "hidden" + EVENT_KEY,

    SHOW: "show" + EVENT_KEY,

    SHOWN: "shown" + EVENT_KEY,

    INSERTED: "inserted" + EVENT_KEY,

    CLICK: "click" + EVENT_KEY,

    FOCUSIN: "focusin" + EVENT_KEY,

    FOCUSOUT: "focusout" + EVENT_KEY,

    MOUSEENTER: "mouseenter" + EVENT_KEY,

    MOUSELEAVE: "mouseleave" + EVENT_KEY

  };

  /**

   * Class definition

   */

  var Tooltip = /*#__PURE__*/function () {

    function Tooltip(element, config) {

      if (typeof Popper__default["default"] === 'undefined') {

        throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');

      } // Private

      this._isEnabled = true;

      this._timeout = 0;

      this._hoverState = '';

      this._activeTrigger = {};

      this._popper = null; // Protected

      this.element = element;

      this.config = this._getConfig(config);

      this.tip = null;

      this._setListeners();

    } // Getters

    var _proto = Tooltip.prototype;

    // Public

    _proto.enable = function enable() {

      this._isEnabled = true;

    };

    _proto.disable = function disable() {

      this._isEnabled = false;

    };

    _proto.toggleEnabled = function toggleEnabled() {

      this._isEnabled = !this._isEnabled;

    };

    _proto.toggle = function toggle(event) {

      if (!this._isEnabled) {

        return;

      }

      if (event) {

        var dataKey = this.constructor.DATA_KEY;

        var context = $__default["default"](event.currentTarget).data(dataKey);

        if (!context) {

          context = new this.constructor(event.currentTarget, this._getDelegateConfig());

          $__default["default"](event.currentTarget).data(dataKey, context);

        }

        context._activeTrigger.click = !context._activeTrigger.click;

        if (context._isWithActiveTrigger()) {

          context._enter(null, context);

        } else {

          context._leave(null, context);

        }

      } else {

        if ($__default["default"](this.getTipElement()).hasClass(CLASS_NAME_SHOW)) {

          this._leave(null, this);

          return;

        }

        this._enter(null, this);

      }

    };

    _proto.dispose = function dispose() {

      clearTimeout(this._timeout);

      $__default["default"].removeData(this.element, this.constructor.DATA_KEY);

      $__default["default"](this.element).off(this.constructor.EVENT_KEY);

      $__default["default"](this.element).closest('.modal').off('hide.bs.modal', this._hideModalHandler);

      if (this.tip) {

        $__default["default"](this.tip).remove();

      }

      this._isEnabled = null;

      this._timeout = null;

      this._hoverState = null;

      this._activeTrigger = null;

      if (this._popper) {

        this._popper.destroy();

      }

      this._popper = null;

      this.element = null;

      this.config = null;

      this.tip = null;

    };

    _proto.hide = function hide(callback) {

      var _this2 = this;

      var tip = this.getTipElement();

      var hideEvent = $__default["default"].Event(this.constructor.Event.HIDE);

      var complete = function complete() {

        if (_this2._hoverState !== HOVER_STATE_SHOW && tip.parentNode) {

          tip.parentNode.removeChild(tip);

        }

        _this2._cleanTipClass();

        _this2.element.removeAttribute('aria-describedby');

        $__default["default"](_this2.element).trigger(_this2.constructor.Event.HIDDEN);

        if (_this2._popper !== null) {

          _this2._popper.destroy();

        }

        if (callback) {

          callback();

        }

      };

      $__default["default"](this.element).trigger(hideEvent);

      if (hideEvent.isDefaultPrevented()) {

        return;

      }

      $__default["default"](tip).removeClass(CLASS_NAME_SHOW); // If this is a touch-enabled device we remove the extra

      // empty mouseover listeners we added for iOS support

      if ('ontouchstart' in document.documentElement) {

        $__default["default"](document.body).children().off('mouseover', null, $__default["default"].noop);

      }

      this._activeTrigger[TRIGGER_CLICK] = false;

      this._activeTrigger[TRIGGER_FOCUS] = false;

      this._activeTrigger[TRIGGER_HOVER] = false;

      if ($__default["default"](this.tip).hasClass(CLASS_NAME_FADE)) {

        var transitionDuration = Util__default["default"].getTransitionDurationFromElement(tip);

        $__default["default"](tip).one(Util__default["default"].TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);

      } else {

        complete();

      }

      this._hoverState = '';

    };

    _proto.update = function update() {

      if (this._popper !== null) {

        this._popper.scheduleUpdate();

      }

    } // Protected

    ;

    _proto.isWithContent = function isWithContent() {

      return Boolean(this.getTitle());

    };

    _proto.addAttachmentClass = function addAttachmentClass(attachment) {

      $__default["default"](this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);

    };

    _proto.getTipElement = function getTipElement() {

      this.tip = this.tip || $__default["default"](this.config.template)[0];

      return this.tip;

    };

    _proto.setContent = function setContent() {

      var tip = this.getTipElement();

      this.setElementContent($__default["default"](tip.querySelectorAll(SELECTOR_TOOLTIP_INNER)), this.getTitle());

      $__default["default"](tip).removeClass(CLASS_NAME_FADE + " " + CLASS_NAME_SHOW);

    };

    _proto.setElementContent = function setElementContent($element, content) {

      if (typeof content === 'object' && (content.nodeType || content.jquery)) {

        // Content is a DOM node or a jQuery

        if (this.config.html) {

          if (!$__default["default"](content).parent().is($element)) {

            $element.empty().append(content);

          }

        } else {

          $element.text($__default["default"](content).text());

        }

        return;

      }

      if (this.config.html) {

        if (this.config.sanitize) {

          content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn);

        }

        $element.html(content);

      } else {

        $element.text(content);

      }

    };

    _proto.getTitle = function getTitle() {

      var title = this.element.getAttribute('data-original-title');

      if (!title) {

        title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;

      }

      return title;

    } // Private

    ;

    _proto._getPopperConfig = function _getPopperConfig(attachment) {

      var _this3 = this;

      var defaultBsConfig = {

        placement: attachment,

        modifiers: {

          offset: this._getOffset(),

          flip: {

            behavior: this.config.fallbackPlacement

          },

          arrow: {

            element: SELECTOR_ARROW

          },

          preventOverflow: {

            boundariesElement: this.config.boundary

          }

        },

        onCreate: function onCreate(data) {

          if (data.originalPlacement !== data.placement) {

            _this3._handlePopperPlacementChange(data);

          }

        },

        onUpdate: function onUpdate(data) {

          return _this3._handlePopperPlacementChange(data);

        }

      };

      return _extends({}, defaultBsConfig, this.config.popperConfig);

    };

    _proto._getOffset = function _getOffset() {

      var _this4 = this;

      var offset = {};

      if (typeof this.config.offset === 'function') {

        offset.fn = function (data) {

          data.offsets = _extends({}, data.offsets, _this4.config.offset(data.offsets, _this4.element));

          return data;

        };

      } else {

        offset.offset = this.config.offset;

      }

      return offset;

    };

    _proto._getContainer = function _getContainer() {

      if (this.config.container === false) {

        return document.body;

      }

      if (Util__default["default"].isElement(this.config.container)) {

        return $__default["default"](this.config.container);

      }

      return $__default["default"](document).find(this.config.container);

    };

    _proto._getAttachment = function _getAttachment(placement) {

      return AttachmentMap[placement.toUpperCase()];

    };

    _proto._setListeners = function _setListeners() {

      var _this5 = this;

      var triggers = this.config.trigger.split(' ');

      triggers.forEach(function (trigger) {

        if (trigger === 'click') {

          $__default["default"](_this5.element).on(_this5.constructor.Event.CLICK, _this5.config.selector, function (event) {

            return _this5.toggle(event);

          });

        } else if (trigger !== TRIGGER_MANUAL) {

          var eventIn = trigger === TRIGGER_HOVER ? _this5.constructor.Event.MOUSEENTER : _this5.constructor.Event.FOCUSIN;

          var eventOut = trigger === TRIGGER_HOVER ? _this5.constructor.Event.MOUSELEAVE : _this5.constructor.Event.FOCUSOUT;

          $__default["default"](_this5.element).on(eventIn, _this5.config.selector, function (event) {

            return _this5._enter(event);

          }).on(eventOut, _this5.config.selector, function (event) {

            return _this5._leave(event);

          });

        }

      });

      this._hideModalHandler = function () {

        if (_this5.element) {

          _this5.hide();

        }

      };

      $__default["default"](this.element).closest('.modal').on('hide.bs.modal', this._hideModalHandler);

      if (this.config.selector) {

        this.config = _extends({}, this.config, {

          trigger: 'manual',

          selector: ''

        });

      } else {

        this._fixTitle();

      }

    };

    _proto._fixTitle = function _fixTitle() {

      var titleType = typeof this.element.getAttribute('data-original-title');

      if (this.element.getAttribute('title') || titleType !== 'string') {

        this.element.setAttribute('data-original-title', this.element.getAttribute('title') || '');

        this.element.setAttribute('title', '');

      }

    };

    _proto._enter = function _enter(event, context) {

      var dataKey = this.constructor.DATA_KEY;

      context = context || $__default["default"](event.currentTarget).data(dataKey);

      if (!context) {

        context = new this.constructor(event.currentTarget, this._getDelegateConfig());

        $__default["default"](event.currentTarget).data(dataKey, context);

      }

      if (event) {

        context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;

      }

      if ($__default["default"](context.getTipElement()).hasClass(CLASS_NAME_SHOW) || context._hoverState === HOVER_STATE_SHOW) {

        context._hoverState = HOVER_STATE_SHOW;

        return;

      }

      clearTimeout(context._timeout);

      context._hoverState = HOVER_STATE_SHOW;

      if (!context.config.delay || !context.config.delay.show) {

        context.show();

        return;

      }

      context._timeout = setTimeout(function () {

        if (context._hoverState === HOVER_STATE_SHOW) {

          context.show();

        }

      }, context.config.delay.show);

    };

    _proto._leave = function _leave(event, context) {

      var dataKey = this.constructor.DATA_KEY;

      context = context || $__default["default"](event.currentTarget).data(dataKey);

      if (!context) {

        context = new this.constructor(event.currentTarget, this._getDelegateConfig());

        $__default["default"](event.currentTarget).data(dataKey, context);

      }

      if (event) {

        context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = false;

      }

      if (context._isWithActiveTrigger()) {

        return;

      }

      clearTimeout(context._timeout);

      context._hoverState = HOVER_STATE_OUT;

      if (!context.config.delay || !context.config.delay.hide) {

        context.hide();

        return;

      }

      context._timeout = setTimeout(function () {

        if (context._hoverState === HOVER_STATE_OUT) {

          context.hide();

        }

      }, context.config.delay.hide);

    };

    _proto._isWithActiveTrigger = function _isWithActiveTrigger() {

      for (var trigger in this._activeTrigger) {

        if (this._activeTrigger[trigger]) {

          return true;

        }

      }

      return false;

    };

    _proto._getConfig = function _getConfig(config) {

      var dataAttributes = $__default["default"](this.element).data();

      Object.keys(dataAttributes).forEach(function (dataAttr) {

        if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) {

          delete dataAttributes[dataAttr];

        }

      });

      config = _extends({}, this.constructor.Default, dataAttributes, typeof config === 'object' && config ? config : {});

      if (typeof config.delay === 'number') {

        config.delay = {

          show: config.delay,

          hide: config.delay

        };

      }

      if (typeof config.title === 'number') {

        config.title = config.title.toString();

      }

      if (typeof config.content === 'number') {

        config.content = config.content.toString();

      }

      Util__default["default"].typeCheckConfig(NAME, config, this.constructor.DefaultType);

      if (config.sanitize) {

        config.template = sanitizeHtml(config.template, config.whiteList, config.sanitizeFn);

      }

      return config;

    };

    _proto._getDelegateConfig = function _getDelegateConfig() {

      var config = {};

      if (this.config) {

        for (var key in this.config) {

          if (this.constructor.Default[key] !== this.config[key]) {

            config[key] = this.config[key];

          }

        }

      }

      return config;

    };

    _proto._cleanTipClass = function _cleanTipClass() {

      var $tip = $__default["default"](this.getTipElement());

      var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);

      if (tabClass !== null && tabClass.length) {

        $tip.removeClass(tabClass.join(''));

      }

    };

    _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) {

      this.tip = popperData.instance.popper;

      this._cleanTipClass();

      this.addAttachmentClass(this._getAttachment(popperData.placement));

    };

    _proto._fixTransition = function _fixTransition() {

      var tip = this.getTipElement();

      var initConfigAnimation = this.config.animation;

      if (tip.getAttribute('x-placement') !== null) {

        return;

      }

      $__default["default"](tip).removeClass(CLASS_NAME_FADE);

      this.config.animation = false;

      this.hide();

      this.show();

      this.config.animation = initConfigAnimation;

    } // Static

    ;

    Tooltip._jQueryInterface = function _jQueryInterface(config) {

      return this.each(function () {

        var $element = $__default["default"](this);

        var data = $element.data(DATA_KEY);

        var _config = typeof config === 'object' && config;

        if (!data && /dispose|hide/.test(config)) {

          return;

        }

        if (!data) {

          data = new Tooltip(this, _config);

          $element.data(DATA_KEY, data);

        }

        if (typeof config === 'string') {

          if (typeof data[config] === 'undefined') {

            throw new TypeError("No method named \"" + config + "\"");

          }

          data[config]();

        }

      });

    };

    _createClass(Tooltip, null, [{

      key: "VERSION",

      get: function get() {

        return VERSION;

      }

    }, {

      key: "Default",

      get: function get() {

        return Default;

      }

    }, {

      key: "NAME",

      get: function get() {

        return NAME;

      }

    }, {

      key: "DATA_KEY",

      get: function get() {

        return DATA_KEY;

      }

    }, {

      key: "Event",

      get: function get() {

        return Event;

      }

    }, {

      key: "EVENT_KEY",

      get: function get() {

        return EVENT_KEY;

      }

    }, {

      key: "DefaultType",

      get: function get() {

        return DefaultType;

      }

    }]);

    return Tooltip;

  }();

  /**

   * jQuery

   */

  $__default["default"].fn[NAME] = Tooltip._jQueryInterface;

  $__default["default"].fn[NAME].Constructor = Tooltip;

  $__default["default"].fn[NAME].noConflict = function () {

    $__default["default"].fn[NAME] = JQUERY_NO_CONFLICT;

    return Tooltip._jQueryInterface;

  };

  return Tooltip;

}));

//# sourceMappingURL=tooltip.js.map